This invention relates generally to transistors, and more particularly to estimating the amount of current leakage by a plurality of transistors included on an integrated circuit.
Leakage is becoming a very significant contributor to power consumption on an integrated circuit (IC) chip. Leakage may be defined as current that is dissipated by a transistor while the transistor is turned off (when its gate to source voltage Vgs is below its threshold voltage VT). Accurate estimation of leakage for a particular circuit on a chip or a certain portion of a chip containing many circuits (a functional unit) is necessary for an accurate estimate of the power consumption of a chip. Leakage calculations across a variety of conditions (process corners, supply voltages, temperatures, etc.) are required for an accurate estimate and may include consideration of leakage variation or statistics among transistors. Computation of leakage of a single transistor at any particular set of conditions may involve expensive computation, especially if it must be repeated for all transistors and conditions.
For efficiency, it is therefore desirable to compute parameters from which the aggregate leakage power for a collection of transistors can be computed at a particular set of conditions. A common method for doing this is to sum the widths of the transistors (by transistor type and channel length), and to then compute a leakage per unit width under a particular set of conditions, and multiply that by the total width to get the total leakage.
Not all transistors on a chip (or in a region of a chip), however, are leaking at the same time. Thus, to compute the average leakage of such a region, the probability that a transistor is leaking is multiplied by the leakage for each transistor. In the prior art method described above this means multiplying the device widths by their leakage probabilities before summing them.
There are various modes of transistor leakage (channel leakage, gate leakage under different source and drain conditions), and all can be treated in a similar manner (albeit with different leakage probabilities). For simplicity the following discussion will not distinguish among them and simply refer to the combined effects as leakage. In practice the inventive method described below could be applied separately to each of these leakage modes, using the corresponding leakage probabilities.
As one of skill in the art will realize, while a transistor may be represented schematically as being a single transistor of a certain width, the transistor may actually be formed of several parallel connected physical transistors (i.e. with all gates connected together, all drains connected together, and all sources connected together) having individual widths that are smaller than the total but, when summed, equal the total width of the transistor as a whole. These parallel transistors are so-called “finger transistors.”
A limitation of prior art methods is that leakage per unit width of narrow transistor is larger than that for wider transistors. This is an aspect of Narrow Channel Effect (NCE). Thus, simply summing the transistor widths and multiplying by a single leakage per unit width number will give inaccurate (and generally under-estimated) leakage values, because the leakage of a transistor is not strictly proportional to width.
By considering the physical structure of the transistor it may be observed that leakage per transistor must be very close to linear with width for wide devices. If a transistor is wide enough that its end regions do not interact with each other (i.e., there is no lithographic, process, or electrical field impact of one end on the other), then any given segment of the “middle” region of the transistor will have the same leakage as any other equal width segment, and the total leakage will simply be the sum of the end region leakages and the width of the middle region times its leakage per unit width.
One prior art method for accounting for NCE leakage is to compute the leakage for each transistor, multiply it by the probability that the transistor is leaking, and add these probability-weighted leakages across all transistors in the chip or circuit whose leakage is to be computed. Mathematically, if W=width, p=leakage probability, L=leakage, and leakage(W) is the leakage calculation function for a single transistor of width W:Li=pi*leakage(Wi)Ltotal=ΣLiThis method, however, requires that the potentially expensive leakage computation be repeated for all transistors in the design at each condition for which leakage computation is required.
Another prior art method for accounting for NCE leakage is to determine the average transistor width (from the total transistor count and total un-weighted transistor width), in addition to the total leakage probability-weighted transistor width. The leakage per unit width can then be determined based on the average transistor width, allowing some accounting for NCE. Mathematically, if N=transistor count and W, p, L, and leakage(W) are as above:Wtotal=ΣWiWweighted=Σ(Wi* pi)Ltotal=(Wweighted/Wtotal)*N*leakage(Wtotal/N)
If the leakage probabilities of different width transistors are different, however, this method can be inaccurate in the presence of NCE. The following example gives an example of how such calculations may be inaccurate. In this example, two different cases related to two transistors, tx1 and tx2, having different widths w1 and w2, under two different probability cases, case a (with only tx1 leaking) and case b (with only tx2 leaking) are considered.case a: Wtotal=w1+w2Wweighted=w1Ltotal=(w1/(w1+w2))*2*leakage((w1+w2)/2)case b: Wtotal=w1+w2Wweighted=w2Ltotal=(w2/(w1+w2))*2*leakage((w1+w2)/2)If leakage were proportional to width (i.e., leakage(W)=K*W), the prior art aggregate leakages would be exactly correct:case a: Ltotal=(w1/(w1+w2))*2*K*(w1+w2)/2=w1*Kcase b: Ltotal=(w2/(w1 +w2))*2*K*(w1+w2)/2=w2*KBut if leakage is linear with width but not proportional to it (i.e., leakage (W) =L0+K*W) the aggregate leakages will not be correct:
                                                                        L                total                            =                            ⁢                                                (                                                            w                      1                                        /                                          (                                                                        w                          1                                                +                                                  w                          2                                                                    )                                                        )                                *                2                *                                  (                                                            L                      0                                        +                                          K                      *                                                                        (                                                                                    w                              1                                                        +                                                          w                              2                                                                                )                                                /                        2                                                                              )                                                                                                        =                            ⁢                                                2                  *                                      L                    0                                    *                                                            w                      1                                        /                                          (                                                                        w                          1                                                +                                                  w                          2                                                                    )                                                                      +                                                      w                    1                                    *                  K                                                                                                        ≠                            ⁢                                                L                  0                                +                                                      w                    1                                    *                  K                                                                                        case        ⁢                                  ⁢        a                                                                                    L                total                            =                            ⁢                                                (                                                            w                      2                                        /                                          (                                                                        w                          1                                                +                                                  w                          2                                                                    )                                                        )                                *                2                *                                  (                                                            L                      0                                        +                                          K                      *                                                                        (                                                                                    w                              1                                                        +                                                          w                              2                                                                                )                                                /                        2                                                                              )                                                                                                        =                            ⁢                                                2                  *                                      L                    0                                    *                                                            w                      2                                        /                                          (                                                                        w                          1                                                +                                                  w                          2                                                                    )                                                                      +                                                      w                    2                                    *                  K                                                                                                        ≠                            ⁢                                                L                  0                                +                                                      w                    2                                    *                  K                                                                                        case        ⁢                                  ⁢        b            
Thus there is a need for a method of aggregating transistor parameters to allow accurate computation of aggregate leakage that accounts for NCE.